/******************************************************************************* 
 *  Copyright 2007 Amazon Technologies, Inc.  
 *  Licensed under the Apache License, Version 2.0 (the "License"); 
 *  
 *  You may not use this file except in compliance with the License. 
 *  You may obtain a copy of the License at: http://aws.amazon.com/apache2.0
 *  This file is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR 
 *  CONDITIONS OF ANY KIND, either express or implied. See the License for the 
 *  specific language governing permissions and limitations under the License.
 * ***************************************************************************** 
 *    __  _    _  ___ 
 *   (  )( \/\/ )/ __)
 *   /__\ \    / \__ \
 *  (_)(_) \/\/  (___/
 * 
 *  Amazon ECS CSharp Library
 *  API Version: 2007-07-16
 *  Generated: Thu Aug 02 10:15:38 PDT 2007 
 * 
 */

using System;
using System.IO;
using System.Reflection;
using System.Xml.Serialization;
using Amazon.ECS.Model;

namespace Amazon.ECS.Mock
{

    /// <summary>
    /// AmazonECSMock is the implementation of AmazonECS based
    /// on the pre-populated set of XML files that serve local data. It simulates 
    /// responses from Amazon ECS service.
    /// </summary>
    /// <remarks>
    /// Use this to test your application without making a call to 
    /// Amazon ECS 
    /// 
    /// Note, current Mock Service implementation does not valiadate requests
    /// </remarks>
    public  class AmazonECSMock : AmazonECS {
    

        // Public API ------------------------------------------------------------//
    
        
        /// <summary>
        /// Help  Action
        /// </summary>
        /// <param name="action">Help  request</param>
        /// <returns>Help  Response from the service</returns>
        /// <remarks>
        /// 
        /// <p/>
        /// The Help operation provides information about ECS operations and
        /// response groups. For operations, Help lists required and optional
        /// request parameters, as well as default and optional response groups the
        /// operation can use. For response groups, Help lists the operations that can
        /// use the response group as well as the response tags returned by the
        /// response group in the XML response.
        /// <p/>
        /// The Help operation is not often used in customer applications. It can, however, be
        /// used to help the developer in the following ways:
        /// <p/>
        /// <ul>
        /// <li>Provide contextual help in an interactive development environment (IDE) for developerst</li>
        /// <li>Automate documentation creation as part of a developer's toolkit. </li>
        /// </ul>
        /// <p/>
        /// <b>Available Response Groups</b>:
        /// <ul>
        /// <li>Request</li>
        /// <li>Help</li>
        /// </ul>
        ///   
        /// </remarks>
        public HelpResponse Help(params HelpRequest [] request) 
        {
            return Invoke<HelpResponse>("HelpResponse.xml");
        }
        
        /// <summary>
        /// Item Search  Action
        /// </summary>
        /// <param name="action">Item Search  request</param>
        /// <returns>Item Search  Response from the service</returns>
        /// <remarks>
        /// 
        /// <p/>
        /// The ItemSearch operation returns items that satisfy the search
        /// criteria, including one or more search indices
        /// <p/>
        /// ItemSearch returns up to ten search results at a time. When condition
        /// equals "All," ItemSearch returns up to three offers per condition (if they exist),
        /// for example, three new, three used, three refurbished, and three collectible items.
        /// Or, for example, if there are no collectible or refurbished offers, ItemSearch
        /// returns three new and three used offers.
        /// <p/>
        /// Because there are thousands of items in each search index, ItemSearch requires
        /// that you specify the value for at least one parameter in addition to a search index.
        /// The additional parameter value must reference items within the specified search index.
        /// For example, you might specify a browse node (BrowseNode is an ItemSearch parameter),
        /// Harry Potter Books, within the Books product category. You would not get results,
        /// for example, if you specified the search index to be Automotive and the browse node
        /// to be Harry Potter Books. In this case, the parameter value is not associated with
        /// the search index value.
        /// <p/>
        /// The ItemPage parameter enables you to return a specified page of results. The maximum
        /// ItemPage number that can be returned is 400. An error is returned if you try to access
        /// higher numbered pages. If you do not include ItemPage in your request, the first page
        /// will be returned by default. There can be up to ten items per page.
        /// <p/>
        /// ItemSearch is the operation that is used most often in requests. In general,
        /// when trying to find an item for sale, you use this operation.
        /// <p/>
        /// <b>Available Response Groups</b>:
        /// <ul>
        /// <li>Request</li>
        /// <li>Small</li>
        /// <li>Accessories</li>
        /// <li>BrowseNodes</li>
        /// <li>EditorialReview</li>
        /// <li>Images</li>
        /// <li>ItemAttributes</li>
        /// <li>ItemIds</li>
        /// <li>Large</li>
        /// <li>ListmaniaLists</li>
        /// <li>Medium</li>
        /// <li>MerchantItemAttributes</li>
        /// <li>OfferFull</li>
        /// <li>Offers</li>
        /// <li>OfferSummary</li>
        /// <li>Reviews</li>
        /// <li>SalesRank</li>
        /// <li>SearchBins</li>
        /// <li>Similarities</li>
        /// <li>Subjects</li>
        /// <li>Tracks</li>
        /// <li>TagsSummary</li>
        /// <li>Tags</li>
        /// <li>VariationImages</li>
        /// <li>VariationMinimum</li>
        /// <li>Variations</li>
        /// <li>VariationSummary</li>
        /// </ul>
        ///   
        /// </remarks>
        public ItemSearchResponse ItemSearch(params ItemSearchRequest [] request) 
        {
            return Invoke<ItemSearchResponse>("ItemSearchResponse.xml");
        }
        
        /// <summary>
        /// Item Lookup  Action
        /// </summary>
        /// <param name="action">Item Lookup  request</param>
        /// <returns>Item Lookup  Response from the service</returns>
        /// <remarks>
        /// 
        /// <p/>
        /// Given an Item identifier, the ItemLookup operation returns some or all
        /// of the item attributes, depending on the response group specified in the request.
        /// By default, ItemLookup returns an item's ASIN, DetailPageURL, Manufacturer,
        /// ProductGroup, and Title of the item.
        /// <p/>
        /// ItemLookup supports many response groups, so you can retrieve many different
        /// kinds of product information, called item attributes, including product reviews,
        /// variations, similar products, pricing, availability, images of products, accessories,
        /// and other information.
        /// <p/>
        /// To look up more than one item at a time, separate the item identifiers by commas.
        /// <p/>
        /// <b>Available Response Groups</b>:
        /// <ul>
        /// <li>Request</li>
        /// <li>Small</li>
        /// <li>Accessories</li>
        /// <li>BrowseNodes</li>
        /// <li>EditorialReview</li>
        /// <li>Images</li>
        /// <li>ItemAttributes</li>
        /// <li>ItemIds</li>
        /// <li>Large</li>
        /// <li>ListmaniaLists</li>
        /// <li>Medium</li>
        /// <li>MerchantItemAttributes</li>
        /// <li>OfferFull</li>
        /// <li>Offers</li>
        /// <li>OfferSummary</li>
        /// <li>Reviews</li>
        /// <li>SalesRank</li>
        /// <li>Similarities</li>
        /// <li>Subjects</li>
        /// <li>Tracks</li>
        /// <li>TagsSummary</li>
        /// <li>Tags</li>
        /// <li>VariationImages</li>
        /// <li>VariationMinimum</li>
        /// <li>Variations</li>
        /// <li>VariationSummary</li>
        /// </ul>
        ///   
        /// </remarks>
        public ItemLookupResponse ItemLookup(params ItemLookupRequest [] request) 
        {
            return Invoke<ItemLookupResponse>("ItemLookupResponse.xml");
        }
        
        /// <summary>
        /// Browse Node Lookup  Action
        /// </summary>
        /// <param name="action">Browse Node Lookup  request</param>
        /// <returns>Browse Node Lookup  Response from the service</returns>
        /// <remarks>
        /// 
        /// <p/>
        /// Given a browse node ID, BrowseNodeLookup returns the specified browse node's name, children, and ancestors.
        /// The names and browse node IDs of the children and ancestor browse nodes are also returned.
        /// BrowseNodeLookup enables you to traverse the browse node hierarchy to find a browse node.
        /// As you traverse down the hierarchy, you refine your search and limit the number of items returned.
        /// For example, you might traverse the following hierarchy: DVD Used DVDs Kids and Family,
        /// to select out of all the DVDs offered by Amazon only those that are appropriate for family viewing.
        /// Returning the items associated with Kids and Family produces a much more targeted result than a search
        /// based at the level of Used DVDs.
        /// <p/>
        /// Alternatively, by traversing up the browse node tree, you can determine the root category of an item.
        /// You might do that, for example, to return the top seller of the root product category using the
        /// TopSeller response group in an ItemSearch request.
        /// <p/>
        /// You can use BrowseNodeLookup iteratively to navigate through the browse node hierarchy to
        /// reach the node that most appropriately suits your search. Then you can use the browse node ID in
        /// an ItemSearch request. This response would be far more targeted than, for example,
        /// searching through all of the browse nodes in a search index.
        /// <p/>
        /// <b>Available Response Groups</b>:
        /// <ul>
        /// <li>Request</li>
        /// <li>BrowseNodeInfo</li>
        /// </ul>
        ///   
        /// </remarks>
        public BrowseNodeLookupResponse BrowseNodeLookup(params BrowseNodeLookupRequest [] request) 
        {
            return Invoke<BrowseNodeLookupResponse>("BrowseNodeLookupResponse.xml");
        }
        
        /// <summary>
        /// List Search  Action
        /// </summary>
        /// <param name="action">List Search  request</param>
        /// <returns>List Search  Response from the service</returns>
        /// <remarks>
        /// 
        /// <p/>
        /// Given a customer name or Email address, the ListSearch operation
        /// returns the associated list ID(s) but not the list items. To find those,
        /// use the list ID returned by ListSearch with  ListLookup  .
        /// <p/>
        /// Specifying a full name or just a first or last name in the request typically
        /// returns multiple lists belonging to different people. Using Email as the
        /// identifier produces more filtered results.
        /// <p/>
        /// <b>Available Response Groups</b>:
        /// <ul>
        /// <li>Request</li>
        /// <li>ListInfo</li>
        /// <li>ListMinimum</li>
        /// </ul>
        ///   
        /// </remarks>
        public ListSearchResponse ListSearch(params ListSearchRequest [] request) 
        {
            return Invoke<ListSearchResponse>("ListSearchResponse.xml");
        }
        
        /// <summary>
        /// List Lookup  Action
        /// </summary>
        /// <param name="action">List Lookup  request</param>
        /// <returns>List Lookup  Response from the service</returns>
        /// <remarks>
        /// 
        /// <p/>
        /// The ListLookup operation returns, by default, summary information about a
        /// list that you specify in the request. The summary information includes the:
        /// <p/>
        /// <ul>
        /// <li>Creation date of the list</li>
        /// <li>Name of the list's creator</li>
        /// </ul>
        /// <p/>
        /// The operation returns up to ten sets of summary information per page.
        /// <p/>
        /// Lists are specified by list type and list ID, which can be found using ListSearch.
        /// <p/>
        /// You cannot lookup more than one list at a time in a single request.
        /// You can, however, make a batch request to look for more than one list simultaneously.
        /// <p/>
        /// <b>Available Response Groups</b>:
        /// <ul>
        /// <li>Request</li>
        /// <li>ListInfo</li>
        /// <li>Accessories</li>
        /// <li>BrowseNodes</li>
        /// <li>EditorialReview</li>
        /// <li>Images</li>
        /// <li>ItemAttributes</li>
        /// <li>ItemIds</li>
        /// <li>Large</li>
        /// <li>ListFull</li>
        /// <li>ListItems</li>
        /// <li>ListmaniaLists</li>
        /// <li>Medium</li>
        /// <li>Offers</li>
        /// <li>OfferSummary</li>
        /// <li>Reviews</li>
        /// <li>SalesRank</li>
        /// <li>Similarities</li>
        /// <li>Small</li>
        /// <li>Subjects</li>
        /// <li>Tracks</li>
        /// <li>VariationMinimum</li>
        /// <li>Variations</li>
        /// <li>VariationSummary</li>
        /// </ul>
        ///   
        /// </remarks>
        public ListLookupResponse ListLookup(params ListLookupRequest [] request) 
        {
            return Invoke<ListLookupResponse>("ListLookupResponse.xml");
        }
        
        /// <summary>
        /// Customer Content Search  Action
        /// </summary>
        /// <param name="action">Customer Content Search  request</param>
        /// <returns>Customer Content Search  Response from the service</returns>
        /// <remarks>
        /// 
        /// <p/>
        /// For a given customer Email address or name, the CustomerContentSearch
        /// operation returns matching customer IDs, names, nicknames, and residence
        /// information (city, state, and country). In general, supplying an Email
        /// address returns unique results whereas supplying a name more often
        /// returns multiple results.
        /// <p/>
        /// Often you use CustomerContentSearch to find a customer ID that you can
        /// use in the CustomerContentLookup operation, which returns more
        /// extensive customer information.
        /// <p/>
        /// <b>Available Response Groups</b>:
        /// <ul>
        /// <li>Request</li>
        /// <li>CustomerInfo</li>
        /// </ul>
        ///   
        /// </remarks>
        public CustomerContentSearchResponse CustomerContentSearch(params CustomerContentSearchRequest [] request) 
        {
            return Invoke<CustomerContentSearchResponse>("CustomerContentSearchResponse.xml");
        }
        
        /// <summary>
        /// Customer Content Lookup  Action
        /// </summary>
        /// <param name="action">Customer Content Lookup  request</param>
        /// <returns>Customer Content Lookup  Response from the service</returns>
        /// <remarks>
        /// 
        /// <p/>
        /// For a given customer ID, the CustomerContentLookup operation
        /// retrieves all of the information a customer has made public about
        /// themselves on Amazon. Such information includes some or all of the following:
        /// <p/>
        /// <ul>
        /// <li>AboutMe</li>
        /// <li>Birthday</li>
        /// <li>City, State and Country</li>
        /// <li>Customer Reviews</li>
        /// <li>Customer ID</li>
        /// <li>Name</li>
        /// <li>Nickname</li>
        /// <li>Wedding Registry</li>
        /// <li>WishList</li>
        /// </ul>
        /// <p/>
        /// To find a customer ID, use the CustomerContentSearch operation.
        /// <p/>
        /// <b>Available Response Groups</b>:
        /// <ul>
        /// <li>Request</li>
        /// <li>CustomerInfo</li>
        /// <li>CustomerReviews</li>
        /// <li>CustomerLists</li>
        /// <li>CustomerFull</li>
        /// <li>TaggedGuides</li>
        /// <li>TaggedItems</li>
        /// <li>TaggedListmaniaLists</li>
        /// <li>TagsSummary</li>
        /// <li>Tags</li>
        /// </ul>
        ///   
        /// </remarks>
        public CustomerContentLookupResponse CustomerContentLookup(params CustomerContentLookupRequest [] request) 
        {
            return Invoke<CustomerContentLookupResponse>("CustomerContentLookupResponse.xml");
        }
        
        /// <summary>
        /// Similarity Lookup  Action
        /// </summary>
        /// <param name="action">Similarity Lookup  request</param>
        /// <returns>Similarity Lookup  Response from the service</returns>
        /// <remarks>
        /// 
        /// <p/>
        /// The SimilarityLookup operation returns up to ten products per page that are
        /// similar to one or more items specified in the request. This operation is
        /// typically used to pique a customer's interest in buying something similar to what they've already ordered.
        /// <p/>
        /// If you specify more than one item, SimilarityLookup returns the intersection of similar
        /// items each item would return separately. Alternatively, you can use the SimilarityType
        /// parameter to return the union of items that are similar to any of the specified items.
        /// A maximum of ten similar items are returned; the operation does not return additional
        /// pages of similar items. if there are more than ten similar items, running the same
        /// request can result in different answers because the ten that are included in the
        /// response are picked randomly.
        /// <p/>
        /// <b>Available Response Groups</b>:
        /// <ul>
        /// <li>Request</li>
        /// <li>Small</li>
        /// <li>Accessories</li>
        /// <li>BrowseNodes</li>
        /// <li>EditorialReview</li>
        /// <li>Images</li>
        /// <li>Large</li>
        /// <li>ItemAttributes</li>
        /// <li>ItemIds</li>
        /// <li>ListmaniaLists</li>
        /// <li>Medium</li>
        /// <li>Offers</li>
        /// <li>OfferSummary</li>
        /// <li>PromotionDetails</li>
        /// <li>PromotionSummary</li>
        /// <li>Reviews</li>
        /// <li>SalesRank</li>
        /// <li>Similarities</li>
        /// <li>Tracks</li>
        /// <li>VariationMinimum</li>
        /// <li>Variations</li>
        /// <li>VariationSummary</li>
        /// </ul>
        ///   
        /// </remarks>
        public SimilarityLookupResponse SimilarityLookup(params SimilarityLookupRequest [] request) 
        {
            return Invoke<SimilarityLookupResponse>("SimilarityLookupResponse.xml");
        }
        
        /// <summary>
        /// Seller Lookup  Action
        /// </summary>
        /// <param name="action">Seller Lookup  request</param>
        /// <returns>Seller Lookup  Response from the service</returns>
        /// <remarks>
        /// 
        /// <p/>
        /// The SellerLookup operation returns detailed information about sellers and,
        /// in the US locale, merchants. To lookup a seller, you must use their seller ID.
        /// The information returned includes the seller's name, location, average rating by
        /// customers, and the first five customer feedback entries. SellerLookup will not,
        /// however, return the seller's Email or business addresses.
        /// <p/>
        /// <b>Available Response Groups</b>:
        /// <ul>
        /// <li>Request</li>
        /// <li>Seller</li>
        /// </ul>
        ///   
        /// </remarks>
        public SellerLookupResponse SellerLookup(params SellerLookupRequest [] request) 
        {
            return Invoke<SellerLookupResponse>("SellerLookupResponse.xml");
        }
        
        /// <summary>
        /// Cart Get  Action
        /// </summary>
        /// <param name="action">Cart Get  request</param>
        /// <returns>Cart Get  Response from the service</returns>
        /// <remarks>
        /// 
        /// <p/>
        /// The CartGet operation enables you to retrieve the IDs, quantities,
        /// and prices of all of the items, including SavedForLater items in a
        /// remote shopping cart.
        /// <p/>
        /// Because the contents of a cart can change for different reasons,
        /// such as availability, you should not keep a copy of a cart locally.
        /// Instead, use CartGet to retrieve the items in a remote shopping cart.
        /// <p/>
        /// To retrieve the items in a cart, you must specify the cart using the
        /// CartId and HMAC values, which are returned in the CartCreate operation.
        /// A value similar to HMAC, URLEncodedHMAC, is also returned. This value is the
        /// URL encoded version of the HMAC. This encoding is necessary because some
        /// characters, such as + and /, cannot be included in a URL. Rather than
        /// encoding the HMAC yourself, use the URLEncodedHMAC value for the HMAC parameter.
        /// <p/>
        /// CartGet does not work after the customer has used the PurchaseURL to either
        /// purchase the items or merge them with the items in their Amazon cart.
        /// <p/>
        /// If the associated CartCreate request specified an AssociateTag, all CartGet
        /// requests must also include a value for AssociateTag otherwise the request will fail.
        /// <p/>
        /// <b>Available Response Groups</b>:
        /// <ul>
        /// <li>Request</li>
        /// <li>Cart</li>
        /// <li>CartSimilarities</li>
        /// <li>CartTopSellers</li>
        /// <li>CartNewReleases</li>
        /// </ul>
        ///   
        /// </remarks>
        public CartGetResponse CartGet(params CartGetRequest [] request) 
        {
            return Invoke<CartGetResponse>("CartGetResponse.xml");
        }
        
        /// <summary>
        /// Cart Add  Action
        /// </summary>
        /// <param name="action">Cart Add  request</param>
        /// <returns>Cart Add  Response from the service</returns>
        /// <remarks>
        /// 
        /// <p/>
        /// The CartAdd operation enables you to add items to an existing remote shopping cart.
        /// CartAdd can only be used to place a new item in a shopping cart. It cannot be used to increase
        /// the quantity of an item already in the cart. If you would like to increase the quantity of
        /// an item that is already in the cart, you must use the CartModify operation.
        /// <p/>
        /// You add an item to a cart by specifying the item's OfferListingId, or ASIN and ListItemId.
        /// Once in a cart, an item can only be identified by its CartItemId. That is, an item in a cart
        /// cannot be accessed by its ASIN or OfferListingId. CartItemId is returned by CartCreate, CartGet, and CartAdd.
        /// <p/>
        /// To add items to a cart, you must specify the cart using the CartId and HMAC values, which are
        /// returned by the CartCreate operation.
        /// <p/>
        /// If the associated CartCreate request specified an AssociateTag, all CartAdd requests must
        /// also include a value for Associate Tag otherwise the request will fail.
        /// <p/>
        /// <b>Available Response Groups</b>:
        /// <ul>
        /// <li>Request</li>
        /// <li>Cart</li>
        /// <li>CartSimilarities</li>
        /// <li>CartTopSellers</li>
        /// <li>CartNewReleases</li>
        /// </ul>
        ///   
        /// </remarks>
        public CartAddResponse CartAdd(params CartAddRequest [] request) 
        {
            return Invoke<CartAddResponse>("CartAddResponse.xml");
        }
        
        /// <summary>
        /// Cart Create  Action
        /// </summary>
        /// <param name="action">Cart Create  request</param>
        /// <returns>Cart Create  Response from the service</returns>
        /// <remarks>
        /// 
        /// <p/>
        /// The CartCreate operation enables you to create a remote shopping cart.
        /// A shopping cart is the metaphor used by most e-commerce solutions. It is a
        /// temporary data storage structure that resides on Amazon servers. The
        /// structure contains the items a customer wants to buy. In ECS, the shopping
        /// cart is considered remote because it is hosted by Amazon servers.
        /// In this way, the cart is remote to the vendor's web site where the customer
        /// views and selects the items they want to purchase.
        /// <p/>
        /// Once you add an item to a cart by specifying the item's ListItemId and ASIN,
        /// or OfferListing ID, the item is assigned a CartItemId and accessible only
        /// by that value. That is, in subsequent requests, an item in a cart cannot
        /// be accessed by its ListItemId and ASIN, or OfferListingId. CartItemId is
        /// returned by CartCreate , CartGet , and CartAdd .
        /// <p/>
        /// Because the contents of a cart can change for different reasons, such as
        /// item availability, you should not keep a copy of a cart locally. Instead,
        /// use the other cart operations to modify the cart contents. For example,
        /// to retrieve contents of the cart, which are represented by CartItemIds,
        /// use CartGet .
        /// <p/>
        /// Available products are added as cart items. Unavailable items, for example,
        /// items out of stock, discontinued, or future releases, are added as SaveForLaterItems.
        /// No error is generated. The Amazon database changes regularly. You may find a product
        /// with an offer listing ID but by the time the item is added to the cart the product
        /// is no longer available. The checkout page in the Order Pipeline clearly lists
        /// items that are available and those that are SaveForLaterItems.
        /// <p/>
        /// It is impossible to create an empty shopping cart. You have to add at least one
        /// item to a shopping cart using a single CartCreate request. You can add specific
        /// quantities (up to 999) of each item.
        /// <p/>
        /// CartCreate can be used only once in the life cycle of a cart. To modify the
        /// contents of the cart, use one of the other cart operations.
        /// <p/>
        /// Carts cannot be deleted. They expire automatically after being unused for 7 days.
        /// The lifespan of a cart restarts, however, every time a cart is modified.
        /// In this way, a cart can last for more than 7 days. If, for example, on day 6,
        /// the customer modifies a cart, the 7 day countdown starts over.
        /// <p/>
        /// <b>Available Response Groups</b>:
        /// <ul>
        /// <li>Request</li>
        /// <li>Cart</li>
        /// <li>CartSimilarities</li>
        /// <li>CartTopSellers</li>
        /// <li>CartNewReleases</li>
        /// </ul>
        ///   
        /// </remarks>
        public CartCreateResponse CartCreate(params CartCreateRequest [] request) 
        {
            return Invoke<CartCreateResponse>("CartCreateResponse.xml");
        }
        
        /// <summary>
        /// Cart Modify  Action
        /// </summary>
        /// <param name="action">Cart Modify  request</param>
        /// <returns>Cart Modify  Response from the service</returns>
        /// <remarks>
        /// 
        /// <p/>
        /// The CartModify operation enables you to:
        /// <p/>
        /// <ul>
        /// <li>Change the quantity of items that are already in a remote shopping cart.</li>
        /// <li>Move items from the active area of a cart to the SaveForLater area or the reverse</li>
        /// <li>Change the MergeCart setting. </li>
        /// </ul>
        /// <p/>
        /// To modify the number of items in a cart, you must specify the
        /// cart using the CartId and HMAC values that are returned in the
        /// CartCreate operation. A value similar to HMAC, URLEncodedHMAC,
        /// is also returned. This value is the URL encoded version of the HMAC.
        /// This encoding is necessary because some characters, such as + and /,
        /// cannot be included in a URL. Rather than encoding the HMAC yourself,
        /// use the URLEncodedHMAC value for the HMAC parameter.
        /// <p/>
        /// You can use CartModify to modify the number of items in a remote shopping
        /// cart by setting the value of the Quantity parameter appropriately. You can
        /// eliminate an item from a cart by setting the value of the Quantity parameter
        /// to zero. Or, you can double the number of a particular item in the cart by
        /// doubling its Quantity . You cannot, however, use CartModify to add new items to a cart.
        /// <p/>
        /// If the associated CartCreate request specified an AssociateTag, all
        /// CartModify requests must also include a value for Associate Tag
        /// otherwise the request will fail.
        /// <p/>
        /// <b>Available Response Groups</b>:
        /// <ul>
        /// <li>Request</li>
        /// <li>Cart</li>
        /// <li>CartSimilarities</li>
        /// <li>CartTopSellers</li>
        /// <li>CartNewReleases</li>
        /// </ul>
        ///   
        /// </remarks>
        public CartModifyResponse CartModify(params CartModifyRequest [] request) 
        {
            return Invoke<CartModifyResponse>("CartModifyResponse.xml");
        }
        
        /// <summary>
        /// Cart Clear  Action
        /// </summary>
        /// <param name="action">Cart Clear  request</param>
        /// <returns>Cart Clear  Response from the service</returns>
        /// <remarks>
        /// 
        /// <p/>
        /// The CartClear operation enables you to remove all of the items in a remote shopping cart, including
        /// SavedForLater items. To remove only some of the items in a cart or to reduce the quantity
        /// of one or more items, use  CartModify  .
        /// <p/>
        /// To delete all of the items from a remote shopping cart, you must specify the cart using the
        /// CartId and HMAC values, which are returned by the CartCreate operation. A value similar
        /// to the HMAC, URLEncodedHMAC, is also returned. This value is the URL encoded version
        /// of the HMAC. This encoding is necessary because some characters, such as + and /,
        /// cannot be included in a URL. Rather than encoding the HMAC yourself, use the
        /// URLEncodedHMAC value for the HMAC parameter.
        /// <p/>
        /// CartClear does not work after the customer has used the PurchaseURL to either purchase the
        /// items or merge them with the items in their Amazon cart.
        /// <p/>
        /// Carts exist even though they have been emptied. The lifespan of a cart is 7 days since the
        /// last time it was acted upon. For example, if a cart created 6 days ago is modified,
        /// the cart lifespan is reset to 7 days.
        /// <p/>
        /// <b>Available Response Groups</b>:
        /// <ul>
        /// <li>Request</li>
        /// <li>Cart</li>
        /// </ul>
        ///   
        /// </remarks>
        public CartClearResponse CartClear(params CartClearRequest [] request) 
        {
            return Invoke<CartClearResponse>("CartClearResponse.xml");
        }
        
        /// <summary>
        /// Transaction Lookup  Action
        /// </summary>
        /// <param name="action">Transaction Lookup  request</param>
        /// <returns>Transaction Lookup  Response from the service</returns>
        /// <remarks>
        /// 
        /// <p/>
        /// The TransactionLookup operation returns information about up to ten purchases
        /// that have already taken place. Transaction IDs are created whenever a purchase
        /// request is made by a customer.
        /// <p/>
        /// For a specified transaction ID, TransactionLookup returns:
        /// <ul>
        /// <li>Price details</li>
        /// <li>Sale date</li>
        /// <li>Shipping details</li>
        /// <li>Seller details</li>
        /// <li>Item's condition </li>
        /// </ul>
        /// <p/>
        /// For privacy reasons, this operation does not return information about the customer
        /// who purchased the items.
        /// <p/>
        /// <b>Available Response Groups</b>:
        /// <ul>
        /// <li>Request</li>
        /// <li>TransactionDetails</li>
        /// </ul>
        ///   
        /// </remarks>
        public TransactionLookupResponse TransactionLookup(params TransactionLookupRequest [] request) 
        {
            return Invoke<TransactionLookupResponse>("TransactionLookupResponse.xml");
        }
        
        /// <summary>
        /// Seller Listing Search  Action
        /// </summary>
        /// <param name="action">Seller Listing Search  request</param>
        /// <returns>Seller Listing Search  Response from the service</returns>
        /// <remarks>
        /// 
        /// <p/>
        /// The SellerListingSearch operation enables you to search for items offered
        /// by specific sellers. You cannot use SellerListingSearch to look up items sold by merchants.
        /// To look up an item sold by a merchant, use  ItemLookup   or  ItemSearch
        /// along with the MerchantId parameter.
        /// <p/>
        /// SellerListingSearch returns the listing ID or exchange ID of an item.
        /// Typically, you use those values with SellerListingLookup to find out more about those items.
        /// <p/>
        /// Each SellerListingSearch request returns up to ten items. By default, the first ten
        /// items are returned. You can use the ListingPage parameter to retrieve additional pages
        /// of (up to) ten listings.
        /// <p/>
        /// To use ECS, sellers must have less than 100,000 items for sale. Sellers that have more
        /// items for sale should use, instead of ECS, other seller APIs, including the Amazon
        /// Inventory Management System, and the Merchant@ API.
        /// <p/>
        /// <b>Available Response Groups</b>:
        /// <ul>
        /// <li>Request</li>
        /// <li>SellerListing</li>
        /// </ul>
        ///   
        /// </remarks>
        public SellerListingSearchResponse SellerListingSearch(params SellerListingSearchRequest [] request) 
        {
            return Invoke<SellerListingSearchResponse>("SellerListingSearchResponse.xml");
        }
        
        /// <summary>
        /// Seller Listing Lookup  Action
        /// </summary>
        /// <param name="action">Seller Listing Lookup  request</param>
        /// <returns>Seller Listing Lookup  Response from the service</returns>
        /// <remarks>
        /// 
        /// <p/>
        /// The SellerListingLookup operation enables you to return information
        /// about a seller's listings, including product descriptions, availability,
        /// condition, and quantity available. The response also includes the seller's nickname.
        /// Each request requires a seller ID.
        /// <p/>
        /// You can also find a seller's items using ItemLookup. There are, however,
        /// some reasons why it is better to use SellerListingLookup:
        /// <p/>
        /// <ul>
        /// <li>SellerListingLookup enables you to search by seller ID.</li>
        /// <li>SellerListingLookup returns much more information than ItemLookup.</li>
        /// </ul>
        /// <p/>
        /// This operation only works with sellers who have less than 100,000 items for sale.
        /// Sellers that have more items for sale should use, instead of ECS, other APIs,
        /// including the Amazon Inventory Management System, and the Merchant@ API.
        /// <p/>
        /// <b>Available Response Groups</b>:
        /// <ul>
        /// <li>Request</li>
        /// <li>SellerListing</li>
        /// </ul>
        ///   
        /// </remarks>
        public SellerListingLookupResponse SellerListingLookup(params SellerListingLookupRequest [] request) 
        {
            return Invoke<SellerListingLookupResponse>("SellerListingLookupResponse.xml");
        }
        
        /// <summary>
        /// Tag Lookup  Action
        /// </summary>
        /// <param name="action">Tag Lookup  request</param>
        /// <returns>Tag Lookup  Response from the service</returns>
        /// <remarks>
        /// 
        /// <p/>
        /// The TagLookup operation returns entities based on specifying one to five tags.
        /// A tag is a descriptive word that a customer uses to label entities on Amazon's retail website.
        /// Entities can be items for sale, Listmania lists, guides, and so forth. For example, a customer might tag a
        /// given entity with the phrase, "BestCookbook." For more information, see Tags.
        /// <p/>
        /// In the tag-related response groups, Tags and TagSummary specify the amount of informtion returned. The
        /// other tag-related response groups, TaggedGuides, TaggedItems, and Tagged listmaniaLists,
        /// specify the kind of entity tagged.
        /// <p/>
        /// <b>Available Response Groups</b>:
        /// <ul>
        /// <li>Request</li>
        /// <li>Small</li>
        /// <li>Accessories</li>
        /// <li>AlternateVersions</li>
        /// <li>BrowseNodes</li>
        /// <li>Collections</li>
        /// <li>EditorialReview</li>
        /// <li>Images</li>
        /// <li>ItemAttributes</li>
        /// <li>ItemIds</li>
        /// <li>Large</li>
        /// <li>ListmaniaLists</li>
        /// <li>Medium</li>
        /// <li>MerchantItemAttributes</li>
        /// <li>OfferFull</li>
        /// <li>OfferListings</li>
        /// <li>Offers</li>
        /// <li>OfferSummary</li>
        /// <li>PromotionDetails</li>
        /// <li>PromotionSummary</li>
        /// <li>Reviews</li>
        /// <li>SalesRank</li>
        /// <li>ShippingCharges</li>
        /// <li>Similarities</li>
        /// <li>Subjects</li>
        /// <li>TaggedGuides</li>
        /// <li>TaggedItems</li>
        /// <li>TaggedListmaniaLists</li>
        /// <li>TagsSummary</li>
        /// <li>Tags</li>
        /// <li>Tracks</li>
        /// </ul>
        ///   
        /// </remarks>
        public TagLookupResponse TagLookup(params TagLookupRequest [] request) 
        {
            return Invoke<TagLookupResponse>("TagLookupResponse.xml");
        }

        // Private API ------------------------------------------------------------//

        private T Invoke<T>(String xmlResource)
        {
            XmlSerializer serlizer = new XmlSerializer(typeof(T));
            Stream xmlStream = Assembly.GetAssembly(this.GetType()).GetManifestResourceStream(xmlResource);
            return (T)serlizer.Deserialize(xmlStream);
        }
    }
}